/**
 * 消息服务工具类
 * 统一管理消息相关的API调用
 */

const { http } = require('./http.js');

class MessageService {
  /**
   * 获取系统通知列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页大小
   * @returns {Promise}
   */
  static getSystemMessages(params = {}) {
    const defaultParams = {
      typeId: 1, // 系统通知
      pageNum: 1,
      pageSize: 20
    };
    
    // 系统通知不需要userId参数，所有用户都能看到
    const finalParams = { ...defaultParams, ...params };
    // 确保不传递userId参数，避免过滤掉系统通知
    delete finalParams.userId;
    
    return http.get('/hyg/notice/list', finalParams);
  }

  /**
   * 获取个人消息列表
   * @param {Object} params - 查询参数
   * @param {number} params.userId - 用户ID
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页大小
   * @returns {Promise}
   */
  static getPersonalMessages(params = {}) {
    if (!params.userId) {
      return Promise.resolve({ rows: [] });
    }

    const defaultParams = {
      typeId: 2, // 个人消息
      pageNum: 1,
      pageSize: 20
    };
    
    const finalParams = { ...defaultParams, ...params };
    return http.get('/hyg/notice/list', finalParams);
  }

  /**
   * 获取消息详情
   * @param {number} id - 消息ID
   * @returns {Promise}
   */
  static getMessageDetail(id) {
    return http.get(`/hyg/notice/${id}`);
  }

  /**
   * 创建系统通知
   * @param {Object} data - 通知数据
   * @param {string} data.title - 通知标题
   * @param {string} data.content - 通知内容
   * @returns {Promise}
   */
  static createSystemNotice(data) {
    const noticeData = {
      title: data.title,
      content: data.content,
      typeId: 1, // 系统通知
      del: 1 // 保留
    };
    
    return http.post('/hyg/notice', noticeData);
  }

  /**
   * 创建个人消息
   * @param {Object} data - 消息数据
   * @param {string} data.title - 消息标题
   * @param {string} data.content - 消息内容
   * @param {number} data.userId - 用户ID
   * @param {string} data.orderId - 订单ID（可选）
   * @returns {Promise}
   */
  static createPersonalMessage(data) {
    const noticeData = {
      title: data.title,
      content: data.content,
      typeId: 2, // 个人消息
      userId: data.userId,
      del: 1 // 保留
    };
    
    return http.post('/hyg/notice', noticeData);
  }

  /**
   * 更新消息
   * @param {Object} data - 消息数据
   * @param {number} data.id - 消息ID
   * @param {string} data.title - 消息标题
   * @param {string} data.content - 消息内容
   * @returns {Promise}
   */
  static updateMessage(data) {
    return http.put('/hyg/notice', data);
  }

  /**
   * 删除消息
   * @param {number|Array} ids - 消息ID或ID数组
   * @returns {Promise}
   */
  static deleteMessage(ids) {
    if (Array.isArray(ids)) {
      return http.delete('/hyg/notice/' + ids.join(','));
    } else {
      return http.delete('/hyg/notice/' + ids);
    }
  }

  /**
   * 批量获取消息（系统通知 + 个人消息）
   * @param {Object} params - 查询参数
   * @param {number} params.userId - 用户ID
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页大小
   * @returns {Promise}
   */
  static async getBatchMessages(params = {}) {
    try {
      const [systemRes, personalRes] = await Promise.all([
        this.getSystemMessages(params),
        this.getPersonalMessages(params)
      ]);

      // 检查API返回状态 - 若依框架通常返回 { code: 200, rows: [], total: 0 }
      if (systemRes.code && systemRes.code !== 200) {
        console.error('获取系统消息失败:', systemRes.msg || systemRes.message);
        // 不抛出异常，返回空数组
        console.warn('系统消息获取失败，返回空列表');
      }

      if (personalRes.code && personalRes.code !== 200) {
        console.error('获取个人消息失败:', personalRes.msg || systemRes.message);
        // 不抛出异常，返回空数组
        console.warn('个人消息获取失败，返回空列表');
      }

      // 处理系统消息
      const systemMessages = (systemRes.rows || []).map(item => ({
        ...item,
        type: 'system',
        createTime: item.createTime
      }));

      // 处理个人消息
      const personalMessages = (personalRes.rows || []).map(item => ({
        ...item,
        type: 'order',
        createTime: item.createTime
      }));

      // 合并并按时间排序
      const allMessages = [...systemMessages, ...personalMessages];
      allMessages.sort((a, b) => new Date(b.createTime) - new Date(a.createTime));

      return {
        rows: allMessages,
        total: (systemRes.total || 0) + (personalRes.total || 0)
      };
    } catch (error) {
      console.error('批量获取消息失败:', error);
      
      // 如果是网络错误或API错误，返回空数组而不是抛出异常
      if (error.code === 500 || error.code === -1) {
        console.warn('API调用失败，返回空消息列表');
        return { rows: [], total: 0 };
      }
      
      throw error;
    }
  }

  /**
   * 格式化消息数据
   * @param {Object} message - 原始消息数据
   * @returns {Object} 格式化后的消息数据
   */
  static formatMessage(message) {
    const formatted = { ...message };
    
    // 添加消息类型标识
    if (message.typeId === 1) {
      formatted.type = 'system';
    } else if (message.typeId === 2) {
      formatted.type = 'order';
    }

    // 格式化时间
    if (message.createTime) {
      formatted.createTime = this.formatTime(message.createTime);
    }

    // 格式化订单状态
    if (message.orderStatus) {
      formatted.orderStatusText = this.formatOrderStatus(message.orderStatus);
    }

    // 清理HTML内容，确保安全显示
    if (message.content) {
      formatted.content = this.sanitizeHtml(message.content);
    }

    return formatted;
  }

  /**
   * 清理HTML内容，确保安全显示
   * @param {string} html - 原始HTML内容
   * @returns {string} 清理后的HTML内容
   */
  static sanitizeHtml(html) {
    if (!html) return '';
    
    // 只允许安全的HTML标签
    const allowedTags = {
      'p': 'p',
      'br': 'br',
      'strong': 'strong',
      'b': 'b',
      'em': 'em',
      'i': 'i',
      'u': 'u',
      'code': 'code',
      'pre': 'pre',
      'ul': 'ul',
      'ol': 'ol',
      'li': 'li',
      'blockquote': 'blockquote',
      'h1': 'h1',
      'h2': 'h2',
      'h3': 'h3',
      'h4': 'h4',
      'h5': 'h5',
      'h6': 'h6'
    };
    
    // 移除所有不允许的标签，保留允许的标签
    let sanitized = html;
    
    // 移除script标签和事件处理器
    sanitized = sanitized.replace(/<script[^>]*>.*?<\/script>/gi, '');
    sanitized = sanitized.replace(/on\w+\s*=\s*["'][^"']*["']/gi, '');
    
    // 移除style标签
    sanitized = sanitized.replace(/<style[^>]*>.*?<\/style>/gi, '');
    
    // 移除iframe标签
    sanitized = sanitized.replace(/<iframe[^>]*>.*?<\/iframe>/gi, '');
    
    // 移除object和embed标签
    sanitized = sanitized.replace(/<(object|embed)[^>]*>.*?<\/(object|embed)>/gi, '');
    
    // 移除所有属性，只保留标签名
    sanitized = sanitized.replace(/<(\/?)([a-zA-Z0-9]+)[^>]*>/g, '<$1$2>');
    
    // 只保留允许的标签
    sanitized = sanitized.replace(/<(\/?)([^>]+)>/g, (match, slash, tagName) => {
      const lowerTagName = tagName.toLowerCase();
      if (allowedTags[lowerTagName]) {
        return `<${slash}${lowerTagName}>`;
      }
      return '';
    });
    
    return sanitized;
  }

  /**
   * 格式化时间
   * @param {string} timeStr - 时间字符串
   * @returns {string} 格式化后的时间
   */
  static formatTime(timeStr) {
    try {
      const date = new Date(timeStr);
      const now = new Date();
      const diff = now - date;
      
      // 小于1分钟
      if (diff < 60000) {
        return '刚刚';
      }
      // 小于1小时
      if (diff < 3600000) {
        return Math.floor(diff / 60000) + '分钟前';
      }
      // 小于24小时
      if (diff < 86400000) {
        return Math.floor(diff / 3600000) + '小时前';
      }
      // 小于7天
      if (diff < 604800000) {
        return Math.floor(diff / 86400000) + '天前';
      }
      
      // 超过7天显示具体日期
      return date.toLocaleDateString('zh-CN', {
        month: '2-digit',
        day: '2-digit'
      });
    } catch (error) {
      return timeStr;
    }
  }

  /**
   * 格式化订单状态
   * @param {string} status - 订单状态
   * @returns {string} 格式化后的状态
   */
  static formatOrderStatus(status) {
    const statusMap = {
      'PENDING': '待支付',
      'PAID': '已支付',
      'CLOSED': '已关闭'
    };
    return statusMap[status] || status;
  }

  /**
   * 处理API错误
   * @param {Object} error - 错误对象
   * @returns {string} 友好的错误提示
   */
  static getErrorMessage(error) {
    if (error.code === 500) {
      return '服务器内部错误，请稍后重试';
    } else if (error.code === 401) {
      return '登录已过期，请重新登录';
    } else if (error.code === 403) {
      return '没有权限访问此功能';
    } else if (error.code === 404) {
      return '请求的资源不存在';
    } else if (error.code === -1) {
      return '网络连接失败，请检查网络设置';
    } else {
      return error.message || error.msg || '未知错误，请稍后重试';
    }
  }
}

module.exports = MessageService;
